package org.dtrd.modules.questionnaire.service.impl;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.dtrd.modules.questionnaire.entity.bean.QuestionnaireDetail;
import org.dtrd.modules.questionnaire.entity.bean.QuestionnaireListInfo;
import org.dtrd.modules.questionnaire.entity.po.DtrdEntRdQuestionnaire;
import org.dtrd.modules.questionnaire.entity.request.QuestionnaireListRequest;
import org.dtrd.modules.questionnaire.entity.request.QuestionnairePageRequest;
import org.dtrd.modules.questionnaire.mapper.DtrdEntRdQuestionnaireMapper;
import org.dtrd.modules.questionnaire.service.IDtrdEntRdQuestionnaireService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;


/**
 * <p>
 * 调查问卷表 服务实现类
 * </p>
 *
 * @author xiao
 * @since 2022-06-16
 */
@Slf4j
@DS("multi-datasource1")
@Service
public class DtrdEntRdQuestionnaireServiceImpl extends ServiceImpl<DtrdEntRdQuestionnaireMapper, DtrdEntRdQuestionnaire> implements IDtrdEntRdQuestionnaireService {

    private DtrdEntRdQuestionnaireMapper dtrdEntRdQuestionnaireMapper;

    @Override
    public List<QuestionnaireListInfo> getQuestionnaireList(QuestionnaireListRequest request) {
        LambdaQueryWrapper<DtrdEntRdQuestionnaire> queryWrapper = baseQueryWrapper();
        queryWrapper.eq(DtrdEntRdQuestionnaire::getType, request.getType());
        List<DtrdEntRdQuestionnaire> poList = list(queryWrapper);
        List<QuestionnaireListInfo> dtoList = new ArrayList<>(poList.size());
        if (!poList.isEmpty()) {
            dtoList = poList.stream().map(QuestionnaireListInfo::new).collect(Collectors.toList());
        }
        return dtoList;
    }

    @Override
    public IPage<QuestionnaireListInfo> pageQuestionnaire(QuestionnairePageRequest request) {
        LambdaQueryWrapper<DtrdEntRdQuestionnaire> queryWrapper = baseQueryWrapper();
        IPage<DtrdEntRdQuestionnaire> page = new Page<>(request.getPageNum(), request.getPageSize());
        page = this.page(page, queryWrapper);
        return page.convert(QuestionnaireListInfo::new);
    }

    @Override
    public QuestionnaireDetail getQuestionnaire(Integer dataId) {
        DtrdEntRdQuestionnaire dtrdEntRdQuestionnaire = getById(dataId);
        return Optional.ofNullable(dtrdEntRdQuestionnaire)
                        .map(po -> new QuestionnaireDetail().parseFromPo(po))
                        .orElse(null);
    }

    @Override
    public boolean saveOrUpdateQuestionnaire(QuestionnaireDetail dto) {
        DtrdEntRdQuestionnaire dtrdEntRdQuestionnaire = new DtrdEntRdQuestionnaire();
        if(dto.getDataId() == null){
            dtrdEntRdQuestionnaire = dtrdEntRdQuestionnaire.init();
        }
        dtrdEntRdQuestionnaire.parseFromDto(dto);
        return saveOrUpdate(dtrdEntRdQuestionnaire);
    }

    @Override
    public boolean removeQuestionnaire(Integer dataId) {
        return removeById(dataId);
    }

    public Integer getLastQuestion(String type){
        LambdaQueryWrapper<DtrdEntRdQuestionnaire> wrapper = Wrappers.lambdaQuery(DtrdEntRdQuestionnaire.class)
                .eq(DtrdEntRdQuestionnaire::getType, type)
                .eq(DtrdEntRdQuestionnaire::getIsDel, 0)
                .orderByDesc(DtrdEntRdQuestionnaire::getSort);
        wrapper.last("limit 1");
        DtrdEntRdQuestionnaire lastOne = getOne(wrapper);
        if (lastOne != null) {
            return lastOne.getDataId();
        }
        else {
            return 0;
        }
    }

    private LambdaQueryWrapper<DtrdEntRdQuestionnaire> baseQueryWrapper() {
        return Wrappers.lambdaQuery(DtrdEntRdQuestionnaire.class)
                        .eq(DtrdEntRdQuestionnaire::getIsDel, 0);
    }

    private LambdaUpdateWrapper<DtrdEntRdQuestionnaire> baseUpdateWrapper() {
        return Wrappers.lambdaUpdate(DtrdEntRdQuestionnaire.class)
                        .eq(DtrdEntRdQuestionnaire::getIsDel, 0);
    }

}
